package com.itany.corejava.code15_stream;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

/**
 * @author Miss Chen
 * @version 1.0
 * @date 2024年08月09日16:17
 */
public class Test03_终止操作 {
    private static List<Integer> list= Arrays.asList(11,13,78,98,67,45,34,87,100,300,400,500,600,200);
    public static void main(String[] args) {
        // test01();
        // test02();
        // test03();
        // test04();
        // test05();
        test06();
    }
    public static void test01(){
       // boolean flag= list.stream()
       //          .allMatch(i->i>100);//检查流中所有元素是否都比100大，只要有任意一个不比100大，则返回false
       //  System.out.println(flag);

        // boolean flag2= list.stream()
        //         .anyMatch(i->i>100);//检查流中所有元素是否存在比100大的元素，只要有任意一个比100大，则返回true
        // System.out.println(flag2);

        boolean flag3= list.stream()
                .noneMatch(i->i<0);//所有元素都不满足，则返回true
        System.out.println(flag3);
    }
    public static void test02(){
        // list=new ArrayList<>();
        Optional<Integer> first=list.stream().findFirst();

        //直接取出容器中的值，如果没有值会抛出异常
        // System.out.println(first.get());

        //判断容器中是否有值，有值则取出来，没有可以设置一个默认值
        if(first.isPresent()){
            Integer num=first.get();
            System.out.println(num);
        }else{
            Integer num=first.orElse(0);
            System.out.println(num);
        }

    }

    public static void test03(){
        long count=list.stream().count();
        System.out.println("流中元素的数量:"+count);
    }
    public static void test04(){
        Optional<Integer> max=list.stream().max((a,b)->a-b);
        System.out.println(max.get());//最大值

        Optional<Integer> max2=list.stream().max((a,b)->b-a);
        System.out.println(max2.get());//最小值
    }

    public static void test05(){
        Optional<Integer> min=list.stream().min((a,b)->a-b);
        System.out.println(min.get());//最小值

        Optional<Integer> min2=list.stream().min((a,b)->b-a);
        System.out.println(min2.get());//最大值
    }

    public static void test06(){
        Optional<Integer> reduce=list.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer+integer2;
            }
        });
        System.out.println(reduce.get());

        Optional<Integer> reduce2=list.stream().reduce((a,b)->a+b);
        System.out.println(reduce2.get());


        System.out.println("================");
        Optional<Integer> o=Stream.iterate(1, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+1;
            }
        }).limit(100).reduce((a,b)->a+b);
        System.out.println(o.get());

        // 1-100之和
        Optional<Integer> o2=Stream.iterate(1,i->i+1).limit(100).reduce((a,b)->a+b);
        System.out.println(o2.get());
    }
}
